#!/usr/bin/env python
# -*- coding: UTF8 	-*-

from GladeConnect import GladeConnect
import gtk
import sys
import time
import datetime
import dialogos
import debugwindow
import SimpleTree
import ifd
from strSQL.recepcion_insumo import strSelectRecepcionInsumo
from psycopg2 import connect
import completion
import comunes
import treetohtml


(CODIGO_RECEPCION_INSUMO,
 DESCRIPCION_INSUMO,
 CODIGO_INSUMO,
 CANTIDAD,
 FECHA_RECEPCION,
 HORA_RECEPCION,
 FECHA_VENCIMIENTO,
 LOTE,
 DOCUMENTO,
 CODIGO_TIPO_DOCUMENTO,
 DESCRIPCION_TIPO_DOCUMENTO,
 RUT_PROVEEDOR,
 NOMBRE_PROVEEDOR,
 CODIGO_UNIDAD,
 DESCRIPCION_UNIDAD,
 CODIGO_TEMPORADA,
 DESCRIPCION_TEMPORADA) = range(17)

class wnRecepcionInsumo(GladeConnect):
    def __init__(self, conexion=None, padre=None, root="wnRecepcionInsumo"):
        GladeConnect.__init__(self, "glade/wnRecepcionInsumo.glade", root)
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        self.padre = padre
        if padre is None :
            self.wnRecepcionInsumo.maximize()
            self.frm_padre = self.wnRecepcionInsumo
            self.padre 
        else:
            self.frm_padre = padre.frm_padre
            
        self.crea_columnas()
        self.carga_datos()
        
    def sel_rut(self, completion, model, iter):
        self.rut = model.get_value(iter, 0)
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([CODIGO_RECEPCION_INSUMO, "Código", "str"])
        columnas.append ([DESCRIPCION_INSUMO, "Insumo", "str"])
        columnas.append ([CANTIDAD, "Cantidad", "str"])
        columnas.append ([FECHA_RECEPCION, "Fecha Recepción", "dte"])
        columnas.append ([LOTE, "Lote", "str"])
        columnas.append ([DOCUMENTO, "Documento","str"])
        columnas.append ([NOMBRE_PROVEEDOR, "Proveedor", "str"])
        columnas.append ([RUT_PROVEEDOR, "R.U.T.", "str"])
        columnas.append ([DESCRIPCION_TIPO_DOCUMENTO, "Tipo Documento", "str"])
        columnas.append ([DESCRIPCION_UNIDAD, "Unidad", "str"])
        columnas.append ([DESCRIPCION_TEMPORADA, "Temporada", "str"])
        
        self.carga_datos()
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeRecepcionInsumo)
        self.col_data = [x[0] for x in columnas]
        
    def on_btnImprimir_clicked(self, btn=None):
        t = treetohtml.TreeToHTML(self.treeRecepcionInsumo,"Recepción de Insumos", self.col_data)
        t.show()        
        
    def carga_datos(self, where=None):
        if where is None:
            self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectRecepcionInsumo)
            self.treeRecepcionInsumo.set_model(self.modelo)
        else:
            try:
                sql = strSelectRecepcionInsumo
                sql = sql.replace("ORDER", where)
                self.modelo = ifd.ListStoreFromSQL(self.cnx, sql)
                self.treeRecepcionInsumo.set_model(self.modelo)
            except:
                self.modelo = ifd.ListStoreFromSQL(self.cnx, strSelectRecepcionInsumo)
                self.treeRecepcionInsumo.set_model(self.modelo)

    def on_btnAnadir_clicked(self, btn=None, data=None):
        dlg = dlgRecepcionInsumo(self.cnx, self.frm_padre, False)
        hora = str(time.localtime()[3]).zfill(2)
        minuto = str(time.localtime()[4]).zfill(2)
        dlg.entFechaRecepcionInsumo.set_date(datetime.date.today())
        dlg.entFechaVencimientoInsumo.set_date(datetime.date.today())
        dlg.entHoraRecepcionInsumo.set_text("%s:%s" % (hora, minuto))
        dlg.editando = False
        response = dlg.dlgRecepcionInsumo.run()
        if response == gtk.RESPONSE_OK:
            self.carga_datos()
    
    def on_btnQuitar_clicked(self, btn=None):
        model, it = self.treeRecepcionInsumo.get_selection().get_selected()
        if model is None or it is None:
            return
        codigo = model.get_value(it, CODIGO_RECEPCION_INSUMO)
        documento = model.get_value(it, DOCUMENTO)
        insumo = model.get_value(it, DESCRIPCION_INSUMO)
        proveedor = model.get_value(it, NOMBRE_PROVEEDOR)
        
        if dialogos.yesno("¿Desea eliminar el documento <b>%s, del proveedor %s que recibe el insumo %s</b>?\nEsta acción no se puede deshacer\n" % (documento, proveedor, insumo), self.frm_padre) == gtk.RESPONSE_YES:
            llaves = {'codigo_recepcion_insumo':codigo}
            sql = ifd.deleteFromDict('traza.recepcion_insumo', llaves)
            self.cursor.execute(sql, llaves)
            model.remove(it)
        
    def on_btnPropiedades_clicked(self, btn=None):

        model, it = self.treeRecepcionInsumo.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgRecepcionInsumo(self.cnx, self.frm_padre, False)
        dlg.entCodigoRecepcionInsumo.set_text(model.get_value(it, CODIGO_RECEPCION_INSUMO))
        dlg.spnCantidad.set_value(float(model.get_value(it, CANTIDAD)))
        dlg.entUnidad.set_text(model.get_value(it, DESCRIPCION_UNIDAD))
        dlg.codigo_unidad = dlg.pecUnidad.select(model.get_value(it, DESCRIPCION_UNIDAD), 1)
        dlg.rut_proveedor = dlg.pecProveedor.select(model.get_value(it, NOMBRE_PROVEEDOR), 1)
        dlg.codigo_insumo = dlg.pecInsumo.select(model.get_value(it, DESCRIPCION_INSUMO), 1)
        dlg.codigo_tipo_documento = dlg.pecTipoDocumento.select(model.get_value(it, DESCRIPCION_TIPO_DOCUMENTO), 1)
        
        dlg.entFechaRecepcionInsumo.set_date(comunes.GetDateFromModel(model.get_value(it, FECHA_RECEPCION).split()[0]))
        dlg.entFechaVencimientoInsumo.set_date(comunes.GetDateFromModel(model.get_value(it, FECHA_VENCIMIENTO).split()[0]))
        dlg.entHoraRecepcionInsumo.set_text(model.get_value(it, HORA_RECEPCION))
        dlg.spnNumeroDocumento.set_value(float(model.get_value(it, DOCUMENTO)))
        
        dlg.entLote.set_text(model.get_value(it, LOTE))
        
        dlg.entTemporada.set_text(model.get_value(it, DESCRIPCION_TEMPORADA))
        dlg.codigo_temporada = model.get_value(it, CODIGO_TEMPORADA)
        dlg.pecTemporada.set_selected(True)
        
        dlg.editando = True
        
        response = dlg.dlgRecepcionInsumo.run()
        if response == gtk.RESPONSE_OK:
            self.modelo.clear()
            self.carga_datos()
            
    def on_btnTrazabilidad_clicked(self, btn=None):
        model, it = self.treeRecepcionInsumo.get_selection().get_selected()
        if model is None or it is None:
            return
        
        dlg = dlgTrazabilidadInsumo(self.cnx, self.frm_padre, False)
        
        #poner aqui todo los parametros para el dialogo antes mostrar
        #dlg.dlgTrazabilidadInsumo.run()
            
    def on_btnCerrar_clicked(self, btn=None):
        if self.padre is None:
            self.on_exit()
        else:
            self.padre.remove_tab("Recepción Insumo")
            
    def on_treeRecepcionInsumo_row_activated(self, tree=None, path=None, col=None):
        self.on_btnPropiedades_clicked()

    def on_entFiltroInsumo_changed(self, entry):
        try:
            self.modelo.clear()
        except:
            pass
        where = "WHERE i.descripcion_insumo LIKE '%s' ORDER " % ("%" + self.entFiltroInsumo.get_text().upper() + "%")
        self.carga_datos(where)

class dlgRecepcionInsumo(GladeConnect):
    def __init__(self, conexion=None, padre=None, editando=None):
        GladeConnect.__init__(self, "glade/wnRecepcionInsumo.glade", "dlgRecepcionInsumo")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        
        self.editando = editando
        self.codigo_recepcion_insumo = None
        self.pecTipoDocumento = completion.CompletionTipoDocumento(self.entTipoDocumento,
                self.sel_tipo_documento,
                self.cnx)
        self.pecInsumo = completion.CompletionInsumo(self.entInsumo,
                self.sel_insumo,
                self.cnx)
        
        self.pecProveedor = completion.CompletionProveedor(self.entProveedor,
                self.sel_proveedor,
                self.cnx)
        
        self.pecUnidad = completion.CompletionUnidad(self.entUnidad,
                self.sel_unidad,
                self.cnx)
        
        self.pecTemporada = completion.CompletionTemporada(self.entTemporada,
                self.sel_temporada,
                self.cnx)
        
        #<CODIGO comment="PARA SUGERIR LA MAS NUEVA">
        strSelectCodigoTemporada = """SELECT
                                        codigo_temporada,
                                        'Temporada ' || date_part('year', fecha_inicio) || '-' 
                                        || date_part('year', fecha_termino) as descripcion_temporada
                                        FROM traza.temporada
                                        WHERE abierta = TRUE
                                        ORDER BY codigo_temporada desc"""
                                        
        m = ifd.ListStoreFromSQL(self.cnx, strSelectCodigoTemporada)
        self.codigo_temporada = m[0][0]
        self.entTemporada.set_text(m[0][1])
        self.pecTemporada.set_selected(True)
        #</CODIGO>
        
        self.entInsumo.grab_focus()
        self.dlgRecepcionInsumo.show_all()

    def sel_insumo(self, completion, model, iter):
        self.codigo_insumo = model.get_value(iter, 1)
        
    def sel_tipo_documento(self, completion, model, iter):
        self.codigo_tipo_documento = model.get_value(iter, 1)
        
    def sel_proveedor(self, completion, model, iter):
        self.rut_proveedor = model.get_value(iter, 1)
        
    def sel_unidad(self, completion, model, iter):
        self.codigo_unidad = model.get_value(iter, 1)
    
    def sel_temporada(self, completion, model, iter):
        self.codigo_temporada = model.get_value(iter, 1)
        
    def on_btnAceptar_clicked(self, btn=None, date=None, cnx=None):
        
        cantidad = self.spnCantidad.get_value()
        fecha_recepcion = self.entFechaRecepcionInsumo.get_date()
        fecha_vencimiento = self.entFechaVencimientoInsumo.get_date()
        hora = self.entHoraRecepcionInsumo.get_text()
        
        if hora == "":
            dialogos.error("El campo <b>Hora Recepción</b> no puede estar vacío")
            return
      
        if cantidad <= 0:
            dialogos.error("La <b>cantidad</b> debe ser mayor que 0")
            return
        
        if self.entTemporada.get_text() == "":
            dialogos.error("La temporada no puede ser vacia.")
            return
        
        campos = {}
        llaves = {}
        campos['cantidad_producto']  = cantidad
        campos['codigo_unidad']  = self.codigo_unidad
        campos['codigo_insumo']  = self.codigo_insumo
        campos['rut_proveedor']  = self.rut_proveedor
        campos['codigo_tipo_documento']  = self.codigo_tipo_documento
        campos['numero_documento']  = self.spnNumeroDocumento.get_value()
        campos['hora_recepcion_insumo'] = hora
        campos['lote_producto'] = self.entLote.get_text().upper()
        campos['fecha_recepcion_insumo'] = fecha_recepcion.strftime("%Y/%m/%d")
        campos['fecha_vencimiento'] = fecha_vencimiento.strftime("%Y/%m/%d")
        campos['codigo_temporada'] = self.codigo_temporada
        
        if not self.editando:
            sql = ifd.insertFromDict("traza.recepcion_insumo", campos)
        else:
            llaves['codigo_recepcion_insumo'] = self.entCodigoRecepcionInsumo.get_text()
            sql, campos=ifd.updateFromDict("traza.recepcion_insumo", campos, llaves)
            
        self.cursor.execute(sql, campos)
        self.dlgRecepcionInsumo.hide()
        
    def on_btnCancelar_clicked(self, btn=None):
        self.dlgRecepcionInsumo.hide()
        
class dlgTrazabilidadInsumo(GladeConnect):
    def __init__(self, conexion=None, padre=None, editando=None):
        GladeConnect.__init__(self, "glade/wnRecepcionInsumo.glade", "dlgTrazabilidadInsumo")
        self.cnx = conexion
        self.cursor = self.cnx.cursor()
        
        self.crea_columnas()
        
    def crea_columnas(self):
        columnas = []
        columnas.append ([0, "Código", str])
        columnas.append ([1, "Detalle", "pango"])
        columnas.append ([3, "%", str])
        
        self.modelo = gtk.TreeStore(str, str, object, float)
        SimpleTree.GenColsByModel(self.modelo, columnas, self.treeTrazabilidadInsumo)
        #self.selection = self.treeTrazabilidadInsumo.get_selection()
        #self.selection.connect('changed', self.selection_changed)
        self.col_data = [x[0] for x in columnas]
        
    def on_btnCerrar_clicked(self, btn=None):
        self.dlgTrazabilidadInsumo.hide()
        
if __name__ == '__main__':
    cnx = connect("dbname=traza user=traza password=123 host=localhost")
    #cnx.autocommit()
    sys.excepthook = debugwindow.show
    d = wnRecepcionInsumo(cnx)
    
    gtk.main()
